49 research outputs found
Optimal Embedding of Functions for In-Network Computation: Complexity Analysis and Algorithms
We consider optimal distributed computation of a given function of
distributed data. The input (data) nodes and the sink node that receives the
function form a connected network that is described by an undirected weighted
network graph. The algorithm to compute the given function is described by a
weighted directed acyclic graph and is called the computation graph. An
embedding defines the computation communication sequence that obtains the
function at the sink. Two kinds of optimal embeddings are sought, the embedding
that---(1)~minimizes delay in obtaining function at sink, and (2)~minimizes
cost of one instance of computation of function. This abstraction is motivated
by three applications---in-network computation over sensor networks, operator
placement in distributed databases, and module placement in distributed
computing.
We first show that obtaining minimum-delay and minimum-cost embeddings are
both NP-complete problems and that cost minimization is actually MAX SNP-hard.
Next, we consider specific forms of the computation graph for which polynomial
time solutions are possible. When the computation graph is a tree, a polynomial
time algorithm to obtain the minimum delay embedding is described. Next, for
the case when the function is described by a layered graph we describe an
algorithm that obtains the minimum cost embedding in polynomial time. This
algorithm can also be used to obtain an approximation for delay minimization.
We then consider bounded treewidth computation graphs and give an algorithm to
obtain the minimum cost embedding in polynomial time
A Near-Optimal Depth-Hierarchy Theorem for Small-Depth Multilinear Circuits
We study the size blow-up that is necessary to convert an algebraic circuit
of product-depth to one of product-depth in the multilinear
setting.
We show that for every positive
there is an explicit multilinear polynomial on variables
that can be computed by a multilinear formula of product-depth and
size , but not by any multilinear circuit of product-depth and
size less than . This result is tight up to the
constant implicit in the double exponent for all
This strengthens a result of Raz and Yehudayoff (Computational Complexity
2009) who prove a quasipolynomial separation for constant-depth multilinear
circuits, and a result of Kayal, Nair and Saha (STACS 2016) who give an
exponential separation in the case
Our separating examples may be viewed as algebraic analogues of variants of
the Graph Reachability problem studied by Chen, Oliveira, Servedio and Tan
(STOC 2016), who used them to prove lower bounds for constant-depth Boolean
circuits
Streaming algorithms for language recognition problems
We study the complexity of the following problems in the streaming model.
Membership testing for \DLIN We show that every language in \DLIN\ can be
recognised by a randomized one-pass space algorithm with inverse
polynomial one-sided error, and by a deterministic p-pass space
algorithm. We show that these algorithms are optimal.
Membership testing for \LL For languages generated by \LL grammars
with a bound of on the number of nonterminals at any stage in the left-most
derivation, we show that membership can be tested by a randomized one-pass
space algorithm with inverse polynomial (in ) one-sided error.
Membership testing for \DCFL We show that randomized algorithms as efficient
as the ones described above for \DLIN\ and \LL(k) (which are subclasses of
\DCFL) cannot exist for all of \DCFL: there is a language in \VPL\ (a subclass
of \DCFL) for which any randomized p-pass algorithm with error bounded by
must use space.
Degree sequence problem We study the problem of determining, given a sequence
and a graph , whether the degree sequence of is
precisely . We give a randomized one-pass space
algorithm with inverse polynomial one-sided error probability. We show that our
algorithms are optimal.
Our randomized algorithms are based on the recent work of Magniez et al.
\cite{MMN09}; our lower bounds are obtained by considering related
communication complexity problems
A Unified Method for Placing Problems in Polylogarithmic Depth
In this work we consider the term evaluation problem which is, given a term over some algebra and a valid input to the term, computing the value of the term on that input. In contrast to previous methods we allow the algebra to be completely general and consider the problem of obtaining an efficient upper bound for this problem. Many variants of the problems where the algebra is well behaved have been studied. For example, the problem over the Boolean semiring or over the semiring (N,+,*). We extend this line of work.
Our efficient term evaluation algorithm then serves as a tool for obtaining polylogarithmic depth upper bounds for various well-studied problems. To demonstrate the utility of our result we show new bounds and reprove known results for a large spectrum of problems. In particular, the applications of the algorithm we consider include (but are not restricted to) arithmetic formula evaluation, word problems for tree and visibly pushdown automata, and various problems related to bounded tree-width and clique-width graphs
Small-depth Multilinear Formula Lower Bounds for Iterated Matrix Multiplication, with Applications
The complexity of Iterated Matrix Multiplication is a central theme in Computational Complexity theory, as the problem is closely related to the problem of separating various complexity classes within P. In this paper, we study the algebraic formula complexity of multiplying d many 2x2 matrices, denoted IMM_d, and show that the well-known divide-and-conquer algorithm cannot be significantly improved at any depth, as long as the formulas are multilinear.
Formally, for each depth Delta <= log d, we show that any product-depth Delta multilinear formula for IMM_d must have size exp(Omega(Delta d^{1/Delta})). It also follows from this that any multilinear circuit of product-depth Delta for the same polynomial of the above form must have a size of exp(Omega(d^{1/Delta})). In particular, any polynomial-sized multilinear formula for IMM_d must have depth Omega(log d), and any polynomial-sized multilinear circuit for IMM_d must have depth Omega(log d/log log d). Both these bounds are tight up to constant factors.
Our lower bound has the following consequences for multilinear formula complexity.
Depth-reduction: A well-known result of Brent (JACM 1974) implies that any formula of size s can be converted to one of size s^{O(1)} and depth O(log s); further, this reduction continues to hold for multilinear formulas. On the other hand, our lower bound implies that any depth-reduction in the multilinear setting cannot reduce the depth to o(log s) without a superpolynomial blow-up in size.
Separations from general formulas: Shpilka and Yehudayoff (FnTTCS 2010) asked whether general formulas can be more efficient than multilinear formulas for computing multilinear polynomials. Our result, along with a non-trivial upper bound for IMM_d implied by a result of Gupta, Kamath, Kayal and Saptharishi (SICOMP 2016), shows that for any size s and product-depth Delta = o(log s), general formulas of size s and product-depth Delta cannot be converted to multilinear formulas of size s^{O(1)} and product-depth Delta, when the underlying field has characteristic zero